﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using projet_fichier_objet;
using System.Web.UI.MobileControls;
using Outils;


namespace FichierTxt
{
    class Fichier
    {
        public string Chemin { get; set; }
        public Fichier(string chemin)
        {
            this.Chemin = chemin;
        }

        /// <summary>
        /// Fonction qui affiche le contenu d'un fichier
        /// </summary>
        static public void AffichageFichier(string chemin)
        {
            StreamReader SRfichier = File.OpenText(chemin);
            {
                string Element = "";
                while ((Element = SRfichier.ReadLine()) != null)
                {
                    Console.WriteLine(Element);
                }
            }
        }

        /// <summary>
        /// fonction qui affecte les lignes d'un fichier texte dans un tableau
        /// de string
        /// </summary>
        /// <returns>String[]</returns>
        static public List<string> AffectationDansUnTableau(string chemin)
        {

            StreamReader SRfichier = File.OpenText(chemin);
            List<string> liste = new List<string>();
            string Element = "";
            while ((Element = SRfichier.ReadLine()) != null)
            {
                liste.Add(Element);
            }

            SRfichier.Close();
            return liste;
        }

        /// <summary>
        /// Fonction qui affecte les élément d'un tableau dans un fichier .TXT
        /// respectant une certaine encode.
        /// </summary>
        static public void AffectationFichierTxt(List<Personne> ListDePersonne, string Chemin)
        {
            StreamWriter FichierTodo = File.CreateText(Chemin);
            
            for (int i = 0; i < ListDePersonne.Count; i++)
            {
                if (ListDePersonne[i] != null)
                {
                    FichierTodo.WriteLine(ListDePersonne[i].FormatIdentitePipe);
                }
            }
            FichierTodo.Close();
        }

        /// <summary>
        /// Fonction qui parcours une chaine de caractères et retourne
        /// la position des pipe présent dans la chaine
        /// /// </summary>
        /// <returns>int[] contient les postion des pipes</returns>
        static public List<int> PositionPipe(string chaine)
        {
            int j = 0;

            List<int> TabIndice = new List<int>();

            for (int i = 0; i < chaine.Length; i++)
            {
                if (chaine[i] == '|')
                {
                    TabIndice.Add(i);
                    j++;
                }
            }
            return TabIndice;
        }

        /// <summary>
        /// Récupère les carcatères d'une string se trouvant dans
        /// un interval donné.
        /// </summary>
        /// <returns>string</returns>
        static public string CharInterval(string chaine, int IntervalDebut, int IntervalFin)
        {
            string Caractere = string.Empty;
            for (int i = IntervalDebut; i < IntervalFin; i++)
            {
                Caractere += chaine[i];
            }
            return Caractere;
        }

        static public int CharIntervalId(string chaine, int IntervalDebut, int IntervalFin)
        {
            string Caractere = string.Empty;
            for (int i = IntervalDebut; i < IntervalFin; i++)
            {
                Caractere += chaine[i];
            }
            int id = 0;
            int.TryParse(Caractere, out id);
            return id;
        }

        static public string CharIntervalDate(string chaine, int IntervalDebut, int IntervalFin)
        {
            string Caractere = string.Empty;
            for (int i = IntervalDebut; i < IntervalFin; i++)
            {
                Caractere += chaine[i];
            }
            return Caractere;
        }

        /// <summary>
        /// Fonction qui récupère les différentes caractéristique
        /// d'un intérimaire (ID,Nom,Email,Ville,DateNaissance)
        /// contenu entre les pipes (ou interval donné)
        /// </summary>
        /// <returns></returns>
        public static Personne LoadPersonne(List<int> ListeEntier, string chaine)
        {
            Personne Interimaire = new Personne(); //nouvel intérimaire

            Interimaire.ID = Fichier.CharIntervalId(chaine, 0, ListeEntier[0]);

            Interimaire.Nom = Fichier.CharInterval(chaine, ListeEntier[0] + 1, ListeEntier[1]);

            Interimaire.Email = Fichier.CharInterval(chaine, ListeEntier[1] + 1, ListeEntier[2]);

            Interimaire.Ville = Fichier.CharInterval(chaine, ListeEntier[2] + 1, ListeEntier[3]);

            string DateNaiss = Fichier.CharInterval(chaine, ListeEntier[3] + 1, chaine.Length);
            DateTime Date = new DateTime();
            bool Réussite = DateTime.TryParse(DateNaiss, out Date);
            if (Réussite == true)
            {
                Interimaire.DateNaissance = Date;
            }

            return Interimaire;
        }

        /// <summary>
        /// Recupère la liste des personnes du fichier
        /// </summary>
        /// <returns>List</returns>
        public List<Personne> GetPersonnes()
        {
            List<string> Tabligne = new List<string>();
            List<int> PositionPipe = new List<int>(4);
            List<Personne> personnes = new List<Personne>();

            Tabligne = Fichier.AffectationDansUnTableau(this.Chemin); //affection des lignes du fichier txt dans un tableau
            for (int j = 0; j < Tabligne.Count; j++)
            {
                if (Tabligne[j] != null)
                {
                    PositionPipe = Fichier.PositionPipe(Tabligne[j]); //position des pipes 
                    Personne Interimaire = new Personne(); //nouvelle personne
                    Interimaire = LoadPersonne(PositionPipe, Tabligne[j]);//chargement d'un nouvelle personne par attribut
                    if (Interimaire != null)
                    {
                        
                        personnes.Add(Interimaire); //affectation dans un tableau de personnes
                    }
                }
            }
            return personnes;
        }


        /// <summary>
        /// a toi de la coder
        /// </summary>
        /// <param name="nom"></param>
        /// <returns></returns>
        public List<Personne> GetPersonnesByNom(string nom)
        {
            List<Personne> interimaires = this.GetPersonnes();
            List<Personne> res = new List<Personne>();

            for (int i = 0; i < interimaires.Count; i++)
            {
                nom = nom.ToUpper();

                if (nom == interimaires[i].Nom.ToUpper())
                {
                    res.Add(interimaires[i]);
                }
            }
            return res;
        }

        /// <summary>
        /// Retourne une personne a partir de son Id
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        public Personne GetPersonne(int Id)
        {
            string path = @"C:\Documents and Settings\guillaume.degnero\Mes documents\Visual Studio 2008\Projects\App_Recherche\App_Recherche\ListTODO.txt";//chemin menant au fichier
            
            Fichier Fichiertxt = new Fichier(path);
            List<Personne> ListInterimaire = Fichiertxt.GetPersonnes();
            Personne Interimaire = new Personne();

            for (int i = 0; i < ListInterimaire.Count; i++)
			{
                if (Id == ListInterimaire[i].ID)
                {
                    Interimaire.ID = ListInterimaire[i].ID;
                    Interimaire.Nom = ListInterimaire[i].Nom;
                    Interimaire.Email = ListInterimaire[i].Email;
                    Interimaire.Ville = ListInterimaire[i].Ville;
                    Interimaire.DateNaissance = ListInterimaire[i].DateNaissance;
                    i = ListInterimaire.Count + 1;
                }
			}
            return Interimaire;

        }

        /// <summary>
        /// Parcours une liste de personne et retourne un entier 
        /// position de la personne dans la liste
        /// </summary>
        /// <returns>int</returns>
        public int SearchFullNom(List<Personne> personne, string ValeurRecherche)
        {
            int PositionInterimaire = 0;
            for (int i = 0; i < personne.Count && personne != null; i++)
            {
                personne[i].Nom = personne[i].Nom.ToUpper();
                if (ValeurRecherche == personne[i].Nom)
                {
                    PositionInterimaire = i;
                    i = personne.Count + 1;
                }
                else
                    PositionInterimaire = personne.Count + 1;
            }
            return PositionInterimaire;
        }


        /// <summary>
        /// Fonction qui supprime une personne à l'aide de son id
        /// </summary>
        /// <param name="personne"></param>
        public void DeletePersonne(int id, List<Personne> Liste)
        {
            int position = GetPositionListe(id, Liste);
            Liste.RemoveAt(position);

        }

        /// <summary>
        /// Fonction qui retourne la position de la ligne d'un intérimaire d'une liste
        /// à l'aide de son ID
        /// retourne un entier négatif si aucun résultat
        /// </summary>
        /// <param name="Id"></param>
        /// <param name="liste"></param>
        /// <returns>int</returns>
        public int GetPositionListe(int Id, List<Personne> liste)
        {
            int position = 0;
            Fichier fichierint = new Fichier(Chemin);

            Personne PersoneEdit = fichierint.GetPersonne(Id);
            for (int i = 0; i < liste.Count; i++)
            {
                if (liste[i].Nom == PersoneEdit.Nom && liste[i].ID == PersoneEdit.ID)
                {
                    position = i;
                    i = liste.Count + 1;
                }
                else
                    position = -1;
            }
            return position;

        }


        /// <summary>
        /// Fonction qui parcours une liste de personne ayant un Id (unique)
        /// et qui retourne l'ID max de la liste
        /// </summary>
        /// <param name="liste"></param>
        /// <returns>int ID MAX</returns>
        public int GetIdMax(List<Personne> liste)
        {
            int IdMax = liste[0].ID;

            for (int i = 0; i < liste.Count; i++)
            {
                int Idencour = liste[i].ID;
                if (IdMax < Idencour)
                {
                    IdMax = Idencour;
                }
            }
            return IdMax;
        }
    }
}
